New Star Software Collection/NSS_Collection.iso/3-069 qemm 603/1.ima/DVMAN/APPEND-E.DEV

Text File | 1991-10-08 | 80.7 KB | 1,561 lines

Appendix E

Troubleshooting Guide

 This appendix tries to answer the questions you're most likely to have
when you use DESQview. So, when you have a question or a problem, check
here first. If you can't find the answer, technical support is available by
telephone, FAX, BBS or regular mail. (For details,  please see the booklet
that came with this manual.) But we do have one request. Please have your
DESQview or DESQview 386 serial number ready before you call or write. We
may also need to know about  your hardware, so please have the following
handy:  The make and model of your computer, how much and what kind of
memory you have and the manuals for any add-on cards installed in your
computer. That will help both of us get your problem solved faster.

~Heading~ Problems Starting DESQview

~Subhead~ If DESQview hangs at Startup

 This section discusses how to diagnose and solve problems that may occur
when you start up DESQview.

 If DESQview hangs immediately after you start it up, most likely there's a
conflict between DESQview and the device drivers or memory-resident
programs you've loaded. Things to try are:

~Item~ Rename your AUTOEXEC.BAT and CONFIG.SYS files so that they will not
execute and reboot your computer. (If you are loading a hard drive manager,
you may have to include it in your boot-up if you need to access the
logical drives created by the disk manager, but the idea is to boot with as
clean a start-up as possible to isolate the conflict.) If DESQview starts
up without any major problems, examine the content of both these files to
see which command, program or parameter may be causing a problem.
Reconstruct these files a line at a time to find the offending line,
program, device driver or paramater. Also see page 206, If DESQview Hangs
Unpredictably.

~Item~ Disable (completely remove from memory) any memory-resident programs
you've loaded before DESQview. Then try DESQview again. If it now works,
add these programs back, one by one, until you find the one that doesn't
work. It would be best if you didn't load any memory resident programs
before DESQview, if at all possible. See page 197,  When You Run Memory
Resident Programs.

~Item~ If you have an exPANDed memory (EMS or EEMS) board on your system,
double check the switch settings and be sure you're not getting an exPANDed
memory error messages when you boot your system. Also, consult Appendix B.

~Item~ To ascertain that the problem is not with the DESQview SETUP
configuration, start DESQview with the /NOSETUP switch. (See page 213,
Command Line Switches.) This will load a default setup and ignore the setup
information you provided on installation. If DESQview works, run Setup
again and modify your settings. In particular, be sure the correct graphics
driver is specifiedd.

~Item~ If you are using DV.COM (which is actually a copy of XDV.COM) rather
than DV.EXE, start DESQview with DV.EXE. (Make sure DV.COM does not get
executed by temporarily renaming it.) If DESQview works starting with
DV.EXE and not DV.COM, you most likely have a conflict in memory installed
above 640K or have misconfigured your exPANDed memory board by giving
incorrect or conflicting parameters to the exPANDed memory manager command
in CONFIG.SYS.

 If you have a network board or other special hardware installed, that
hardware may have memory conflicts with your exPANDed memory board in high
memory  above between 640K and 1024K. In either event, this indicates a
memory conflict with a hardware driver. What you need to do is to exclude
that memory that DV.COM (XDV.COM) is using which your hardware needs. You
may do this (preferably) using command line switches for your device driver
or (alternately) by using the /EXCLUDE command line switch for DESQview.
(See page 213, Command Line Switches.)

 First, run DV.COM with the /LIST switch. This will tell you what memory
XDV is using for itself. Then, check the documentation for your video
adapter, or other hardware. If the conflict is with a network card, your
network documentation should tell you what memory addresses it requires, if
an error message did not.

~Item~ If you're not using an IBM or Compaq PC, turn OFF the Optimize
communication? option (see Appendix A). DESQview's optimization technique
may cause a few PC-compatibles to hang.

~Subhead~ If DESQview beeps on startup

~Item~ If DESQview emits a long beep on startup, then hangs, it may be a
keyboard conflict. This happens when using an older keyboard that does not
conform to the standard for enhanced keyboards. Starting DESQview with the
/OLDKEYBOARD switch (which initializes the keyboard as an older model)
usually fixes this. (See page 213, Command Line Switches.)

~Item~ Install DESQview onto a floppy disk and try to start it from that.
If this works, something may have gone wrong with installation. Reinstall
and try again.  If none of the above startup diagnostic techniques produce
any results, there may be a conflict with your particular hard drive, in
which case, call us.

~Heading~ Diagnostic Tips

 This section is a general overview to help you determine what kind of
problem you may be having, why it happens and how you may further research
it. Specific problems and their remedies are discussed in their own
sections of this appendix.

~Subhead~ Problem Solving with DESQview

 DESQview is not like other software you may be using-it is unique. It does
things no other software you use can do and because of this you may be
somewhat perplexed at how to troubleshoot the occasional but important
problem you may be having with it. The main thing to remember is that most
solutions are simple and readily available. When a problem is more complex
to diagnose and solve, it is, in the overwhelming majority of cases, still
quite solvable.

~Subhead~ Software Problems

 In most instances, when Install is completed and Simple setup finished,
DESQview works with most software and on most hardware. You may make
modifications, as described in various parts of the manual, to many aspects
of how DESQview runs or how a program runs under DESQview.


 If your software has trouble running inside DESQview the symptoms can be
quite dramatic. It may hang, lock the keyboard, disrupt the video display
and in extreme instances, even lock up DESQview. If any but the last
symptom occur, you can abort the window by pressing Ctrl-Alt-Del (that will
abort the window, not reboot the computer), reconfigure the program and try
again. If DESQview itself is locked, you must reboot the machine. when
starting to use DESQview it is a good idea to save often while working in
programs, particularly before switching windows, until you are confident
that a mis-behaved or misconfigured program won't hang DESQview or any
other programs running concurrently.

 DESQview assumes that most hardware and software is well behaved. If a
particular software product does not behave as DESQview expects, according
to the default settings in the program information file, you can change
those settings. Most, if not all, initial software problems can be solved
by using the Change a Program Menu or the DESQview Setup program.

~Subhead~ Not Enough Memory to Run a Program

 Probably the most common source of problems with software running inside
DESQview is that not enough memory has been allocated for a particular
program. Insufficient memory problems have various symptoms, for example,
display problems, hanging, working perfectly until a certain feature of a
program is used. These symptoms may or may not generate any error message
and may even seem to be random. Give a program more memory at the first
sign of problems by increasing the number in the Memory Size (in K) field
of the Change a Program menu. You may also specify a number in Maximum
program memory size that is larger than Memory Size (in K). See page 202,
How to Run Very Large Programs. If that solves a software problem, and you
feel the program shouldn't require that much memory, you can always step it
down.

~Subhead~ Determining the Maximum Memory DESQview can Give a Program

 To find out what the maximum memory your system can offer a program inside
DESQview in its current configuration, run Memory Status as the first
program and note the amount of Largest Available Conventional memory. (See
Appendix B for a discussion of the Memory Status program.) Note that the
largest available conventional memory is larger for the first window you
can open than it is for subseqently opened windows. If you have a program
that is a memory hog, always load it first. You can increase the amount of
memory below 640K that DESQview 386 can allocate for a program by using
QEMM-386 to load memory resident programs, DOS resources and device drivers
into memory between 640K and 1MB, leaving as much of the precious memory
below 640K for your programs as possible.

~Subhead~ Test a Recalcitrant Program in a Big DOS Window

 If you are having problems running a program inside a DESQview window, and
it runs fine outside of DESQview, open a Big DOS window, navigate to the
program's directory and start it as you would from DOS. If it runs in a Big
DOS window, it can definitely be configured to run in a DESQview window.
Note that on some installations, the Big DOS window is configured for
virtualization. If it is, turn the Virtualize Text/Graphics option OFF (N),
at first, for testing.

~Subhead~ Program Information File remedies

 Try to think of the difficulty you are having in terms of DESQview's
features: Does the program need to be Virtualized? Can it run in
Background? Can it be Swapped out? Does it have enough, and the right kinds
of memory allocated to it? You can use the Change a Program menu as a
diagnostic tool by cloning a Program Information File as follows:

 After opening the Change a Program menu, change Keys to Use on Open Menu.
This creates a clone of the original, with different startup keystrokes,
and all of the other settings the same. (The original is left as it was.)
You can then make selective changes to the fill-in fields and toggles to
find the precise settings to make your program work in DESQview, or to make
it perform differently, keeping the original intact. You can delete the
original when you no longer need it. If a particular program still exhibits
difficulty running under DESQview, run it as the only window, if you can,
to make sure it is not actually a conflict with another program in memory
causing the problem.

 If your problems are not resolved by checking all settings and readjusting
them according to information in the manual, you will need to research your
problem by reading further in these appendices, the QEMM or QRAM manual (if
you are using QEMM or QRAM) and the documentation for your memory card or
other hardware. This may require a commitment on your part to learn more
about your computer and your software than you already know, even if you
have used them for some time.

~Subhead~ Hardware Memory Problems

 Not enough memory to run a program is usually software problem. Memory
conflict is usually, but not always, a hardware problem. You can not
identify the source of a memory conflict if you do not know, at the very
least, how much memory you have and what kind of memory it is. You may also
need to know, or learn, how your computer, add-on boards and peripherals or
a particular software package uses that memory.  If you need to diagnose a
hardware memory problem, Quarterdeck's Manifest program can help.

~Subhead~ Hardware problems

 Information about your hardware, such as what memory addresses your video
adapter board uses, or whether or not you have a bus mastering hard drive,
is in the documentation for these products or available from your hardware
vendor or manufacturer. You may be able to diagnose hardware/software
memory conflicts by using an analysis utility, such as Quarterdeck
Manifest. What you are looking for is software or hardware that competes
for the same memory address or hardware interrupt. You may never have seen
problems from such a conflict before you used DESQview because you were
running one program at a time and it had the whole computer to  itself. For
instance some hardware that uses bus mastering causes a memory error when
starting a program that uses exPANDed memory inside DESQview. Drivers for
these devices usually have command line parameters (sometimes referred to
as switches) which can be used to resolve conflicts.

 Video adapter cards which support autoswitching have been known to
sometimes cause problems with DESQview, when autoswitching (sometimes also
called autodisplay) is enabled. Disable autoswitching on your video adapter
card if you experience crashing that scrambles your video display or a
program displays an anomalous video mode when you switch away from it.
Letting DESQview manage the mode-switching is always preferable. Disabling
autoswitching frequently fixes other problems with DESQview as well;
autoswitching video cards have been known to cause rebooting, random
crashes, application malfunction and keyboard locking.

 Autoswitching is not the only thing that can cause video problems.  See
the section on Display Problems in this appendix also.

 Hardware problems with DESQview, when they happen can be hardware
specific, even if you believe your system is not all that odd. It probably
is not odd at all, it's just trying to do something that conflicts with
QEMM, QRAM, DESQview or another program. In most cases, you can adjust for
this using command line switches for either the hardware driver or the
memory management software, excluding that range of memory that your
hardware wants. Even one of a group of seemingly identical computers, the
same brand and model, has been known to have a problem with DESQview when
the computers have been set up in a slightly different way.

 Hardware sometimes takes memory for itself on startup which may conflict
with memory DESQview is trying to use. We've also seen ROM chips which do
not correctly report the memory addresses they use, network cards and video
adapters that take more memory than they report. Then, when DESQview uses
the unreported memory, suddenly the conflicting device will not work. For
problems like these, you need to determine the memory used for these
devices, either from the hardware documentation or from the manufacturer or
the device, and exclude more memory for these devices. (See \EXCLUDE, page
213, Command Line Switches.)

 Don't be intimidated by your hardware documentation. Though it might seem
daunting, the hardware manual can provide just the information you need to
resolve a DESQview conflict. If possible, you should contact your hardware
or software vendor or manufacturer to see if they have information on
running their product with DESQview; many do. In the case of, for instance,
network software, some vendors have special drivers which work with
DESQview when the one shipped with the network card will not.

~Subhead~ Technical Support

 At Quarterdeck Technical Support, we log demonstrable conflicts as we hear
about them. If you are having trouble that you cannot analyze and correct
with the information in your manual(s), and you have an active support
account, you may call, write or FAX us for assistance. We'll need your
registered serial number when you do.

 We usually have fixes for hardware problems we know about. Commonly,
hardware and software vendors configure their products to work with
DESQview when problems are reported. For instance, if your problem is
caused by a ROM BIOS incompatibility, it is likely that an upgrade of your
ROM BIOS is available from your hardware vendor. If you call us regarding
what you suspect to be a hardware problem, please also have all your
hardware manuals handy. When we know exactly what hardware is installed on
your computer, we can find any information we have on previously reported
problems with that hardware. If we've seen the problem before, we probably
have the solution. If not, we'll work with you to find one.

 If you have just purchased DESQview, your support account is active for 90
days. If you have recently upgraded and are experiencing problems, your
support account is generally reactivated for 90 days. Other support plans
are outlined in the Passport Support pamphlet that came with your
Quarterdeck software.

 Electronic (BBS) and FAX support is available. We keep a collection of
device drivers and technical notes on our BBS and other BBSs we support. Be
sure to keep the literature that came with your DESQview package. It
details the various support options available to you and how you may access
them.

~Heading~ Problems Starting Programs

 This section discusses problems you may have starting up a program in
DESQview.

~Subhead~ If a Program Won't Start up

 If you can't get a program to start up at all in DESQview, but you've
verified that it runs correctly outside of DESQview:

~Step~ First, run Change a Program on the program and note the values of
the various fields and options.

~Step~ Second, check if the Close on exit option is ON (Y) or blank. If it
is, turn it OFF (N).

~Item~ Third, try starting the program again. This time, the program window
will remain open after startup fails so you can see any error messages that
might occur. Now, examine the contents of the window:

 If it shows the message, "Bad command or file name," or shows a message
from the program indicating that it can't find its overlay files, the most
likely problem is that the path or program name in the Program or Directory
fields is wrong.

 If the command specified in the Program field appears in the window and
the program begins to load, but then either hangs or drops back to the DOS
prompt, the most likely problem is that you need to allocate more memory
for the program by increasing Memory Size (in K). Often, when you need more
memory, a message indicating memory error will appear, but not always.

~Step~ Fourth, if the contents of the window aren't helpful, check if the
program requires any system drivers that may not have been loaded. See page
197, When You Run Memory-Resident Programs.

~Step~ Finally, after correcting the problem, run Change a Program again
and turn the Close on exit option back ON (Y) if it was ON to start with or
blank it out if it was blank to start with. (Blank is usually the best
choice.)

~Subhead~ If Starting Up a Program Hangs DESQview

 If DESQview hangs when you start up a program, the most likely problem is
that it's been given too little memory.

 Most programs won't load with insufficient memory.  However, some programs
that use overlays don't check that there's sufficient room to load their
overlays.

 If you load such a program with insufficient memory, its overlay will load
over another program's memory area.  The result will depend on
circumstance. Sometimes the system will hang immediately. Sometimes the
system will work perfectly well until you switch to the program that was
damaged.

 If you suspect this is your problem, increase the amount of memory
allocated in Memory Size (in K) on the Change a Program menu (see page 120)
and then repeat the sequence that caused the hang. Also, see page 202, How
to Figure Out the Amount of Memory a Program Needs.

~Subhead~ If You Get an Out of Memory Message When You Start Up a Program

 There are three basic types of out of memory messages you can get:

~Item~ If no window opens but, instead, a message appears in red on top of
the Open Window menu, consult Startup Messages in Appendix F.

~Item~ If the program window opens, and the DOS copyright notice appears,
any message you get comes from DOS. The message, "Program too big to fit in
memory" means that you didn't allocate enough space to load the program.
Change Memory Size (in K) on the Change a Program menu. Also, see page 202,
How to Figure Out the Amount of Memory a Program Needs.

~Item~ If the program window opens, but no DOS copyright notice appears,
the program is being loaded by DESQview. Consult Load Messages and System
Messages in Appendix F.

~Subhead~ If Your RAM Disk, Print Spooler, Disk Cache, or Expanded Memory
Doesn't Work

 If you have an add-on memory board that you use as a RAM disk, print
spooler, or disk cache, or if you an exPANDed memory board, but you can't
get any of its features to work, the most likely cause is that you haven't
loaded the correct drivers. Also, QEXT or another memory manager may be
using the same memory as the RAM disk software wants. Be sure to check
command line parameters for you memory manager and exclude, or designate as
exTENDed memory, the amount of memory you want saved for a RAM drive. Some
older versions of Microsoft RAMDRIVE are misbehaved. Update your version,
if you are experiencing problems. Using a version of VDISK that is
different than your version of DOS will also cause problems.

 Never create a RAM disk in memory below 640K.  Doing so uses up memory
you'll need to run programs. You should create a RAM disk only if you have
add-on memory above 640K, exTENDed memory above 1MB, or an exPANDed (EMS)
memory board. See Appendix B if you have an enhanced exPANDed (EEMS) memory
board.

 ExPANDed memory drivers are always loaded in CONFIG.SYS. RAM disk, print
spooler, and disk cache drivers are usually loaded in AUTOEXEC.BAT, but
don't have to be. Check your user's manual for these products. Also see
page 197, When You Run Memory-Resident Programs.

~Subhead~ If the DOS Services Backup or Format Commands Won't Work

 The most common DOS commands Copy, Directory, Erase, Rename, Type are
built into DOS. The remaining commands Backup, Format, and so forth require
that a program be loaded. If the Backup and Format commands won't work,
it's usually because the DOS Path command, at the time you started up
DESQview, didn't include a path to the files BACKUP.COM and FORMAT.COM.
Most commonly, these program files are kept in the root directory or in a
DOS directory.

 To solve this problem, close down DESQview, add the appropriate Path
command then restart DESQview.

 If you're running on a floppy-based system, see Appendix D

~Heading~ General Information

 This section discusses some important general information you should know
about using DESQview.

~Subhead~ When You Run Communications Programs

 It is important that communications programs get enough clock ticks to
process information as it is received. This is especially critical for
high-speed communications, as more information is being received per clock
tick.

 Communications programs get information either through a hardware
interrupt or by polling. If you are experiencing problems, find out which
method your communications program uses. If it uses the polling method, it
is unlikely that it would work in DESQview. Communications programs, as a
rule, should be non-swappable, however, see page 210, Swapping
Communications Programs for an additional note on this.

 If you want to telecommunicate in the background, be sure the program is
set up to run in background, and be sure that background programs are
getting enough clock ticks in your setup configuration, or by setting this
from the Tune Performance menu.

 Be sure you have no conflict on the same COM port. For instance, if you
have a mouse and a communications program attached to the same port, you
can only use one of them. You may have been able to use them both on the
same port when you were running only one program at a time, however, if you
have two programs in memory, one of which is using the mouse and another of
which is using the modem on the same COM port, it is likely to cause
problems inside DESQview. Even if both programs are not in memory at the
same time, if you set up DESQview with two devices on the same port, it
will cause a conflict.

~Subhead~ When You Run Terminal Emulation Programs

 In general, when running terminal emulation programs, you should use the
same diagnostic guidelines as for most programs. Check device drivers
first. Remove any TSRs and drivers you can possibly live without from
memory or load them high, if you can. Additionally, you may need to
experiment by loading some of the drivers before DESQview and others in the
DESQview window, before the terminal emulation software is run. Some
versions of IRMA, for instance, run better in a DESQview window if you do
not use their keyboard driver, KYBDDRV.SYS.

 Some versions of IBM 3720 terminal emulation disable certain features when
they detect that they are running in DESQview. There is a driver available
from the Quarterdeck BBS, NOVER.COM, which can be used to overcome this, if
you want. Refer to the support pamphlet that came with your copy of
DESQview for information on accessing our BBS. If you are losing connection
with the mainframe running the terminal emulation program inside DESQview,
and don't have this problem outside of DESQview, check to see if the
mainframe simply needs a little more time to receive a signal from the PC.
If so, adjust the mainframe accordingly.

 Use the Change a Program menu to configure your terminal emulation program
to run inside a DESQview window. With terminal emulation software, always
make sure the Program Information file is one you have created with the
Change a Program menu and not one that comes with the program. If your
terminal emulation program causes problems for other programs when it runs
in background, you must set Runs in Background OFF (or enter D in this
field ~dash~ which will run the program in background except when another
program or DESQview is making a DOS call. See page 128.) You should make a
terminal emulation program non-swappable if it is configured to run in
background and you expect that, while running in background, it will be
transmitting or receiving information. Since the program may not use a
Serial Port, DESQview will not automatically do this for you unless you
specify it.

 If the problem seems to be a keyboard problem, refer to the section on
Keyboard Conflict at the end of Chapter 7, Changing a Program's
information. For instance, some terminal emulation programs grab keystrokes
from a foreground program when running in background. To remedy this, you
should set Keyboard Conflict to 4. Also, in DESQview Setup, you should have
Maintain Separate Shift States? set to "Y."

 If you suspect a memory problem, check the program and the hardware's
documentation to see if either the software or hardware use any memory
between 640K and 1024K. If so, exclude this memory from DESQview or
(preferably) your memory manager. (See \EXCLUDE in the section on Command
Line Switches at the end of this Appendix.)

 Also, be aware that some general purpose Communications programs, like
Relay and Crosstalk might be compatible with your terminal emulation
hardware and may be able to interface with a mainframe better in DESQview
than dedicated terminal emulation software.

~Subhead~ When You Run Memory-Resident Programs

 Most of the programs you use Lotus 1-2-3, WordPerfect, dBASE III Plus,
etc., are designed to run alone.  However, there are memory-resident
programs that are designed to remain in memory while you run other programs
(excluding DESQview itself.) These include: keyboard enhancers such as
ProKey, SuperKey, desktop accessories such as SideKick, device drivers for
exPANDed memory, mice, print spoolers, RAM disks (VDISK), disk caches,
plotters, multiple hard disk drive managers, communications ports, and
other peripheral devices are also memory resident. These drivers are
usually loaded automatically by your CONFIG.SYS or AUTOEXEC.BAT file.

 Keyboard Enhancers. DESQview's Learn feature (see Chapter 5) provides
built-in keystroke macros, eliminating, for most of you, the need to use
other keyboard enhancers with DESQview. If for some other reason you want
to continue using one, you should run it in a DESQview window. (We
recommend that you create a batch file that loads the keyboard enhancer and
then the program you're using.)

 Desktop accessories. If you use desktop accessory programs, we recommend
that you run these programs in DESQview windows, rather than loading them
before you start up DESQview. Running them in a DESQview window gives you
three major advantages:

~Item~ The program can be swapped to disk, RAM disk, or exPANDed memory,
thereby making its memory available to run other programs when necessary.

~Item~ Programs running background continue to run while you use the
memory-resident program. If you load a memory-resident program before you
start up DESQview, background processing stops whenever you switch to it.

~Item~ You're less likely to encounter conflicts between the
memory-resident program and DESQview or between the memory-resident program
and programs running in other windows. DESQview can exert far more control
over a memory-resident program running in a window than it can over the
same program loaded before you start up DESQview.

 System Drivers. If you use DOS's Mode or Print commands, or load device
drivers, we recommend that you do so before you load DESQview. (Drivers
loaded by CONFIG.SYS must be loaded first.)

 In your DESQview directory are two TSR device drivers which may be used in
DESQview windows. DVANSI.COM is a DESQview-compatible ANSI driver. If your
program needs ANSI.SYS, run DVANSI.COM in the window before starting the
program. If you use DVANSI.COM then you do not need to have the line,
DEVICE=ANSI.SYS in your CONFIG.SYS file. (DESQview will ignore it.) If you
wish to use another ANSI driver instead of DVANSI.COM, use the DESQview
program, DEVICE.COM with the syntax:

                       DEVICE filename

 to load the driver in a DESQview window.

 DEVICE.COM may be used to load certain other device drivers in a window.
You will get a message indicating failure if a particular device driver
(typically "block" type devices) cannot be loaded by DEVICE.COM, in which
case you will need to load it in CONFIG.SYS.

 If you load a device driver in a DESQview window, it will be available
only to programs running in that window. If you load it before starting up
DESQview, it will be available to all the programs running in DESQview.

 The Quarterdeck exTENDed memory manager, which can be used on 80286 and
80386 computers is called QEXT.SYS. If you want DESQview to use exTENDed
memory, put DEVICE=QEXT.SYS in your CONFIG.SYS file. You must use DV.COM in
order for DESQview to be able to use the exTENDed memory. This driver
supports XMS and should be used instead of Microsoft's HIMEM.SYS.

~Subhead~ When You Run Several Copies of the Same Program Simultaneously

 If you need to use DOS SHARE, load it before DESQview for those programs
which support and require file locking. DESQview does not implement any
file locking on its own. When you run two or more copies of the same
program, be aware that some programs use fixed file names for data or
temporary files. If your program does this, running two copies will almost
certainly fail. Second, if you try to modify the same file in two different
windows at the same time, only one set of changes will be retained ~dash~
usually the last set you save to disk.

~Subhead~ Before You Close a DESQview Window or Quit DESQview

 Before you close a DESQview window, be sure that all files in use by the
program running in the window are closed. As a rule, before you close a
window, issue the program's command to close down all its files, and wait
until this command has finished.

 Before you Quit DESQview, be sure that all the files in use by all the
programs currently running are closed. Use the program's quit command to
close down each window before you quit DESQview.

~Subhead~ When You Use a Backup Program

 When you back upfiles using the DOS Services' Backup command, perform DOS
BACKUP in a DOS window or use another backup program, be sure that all
files being backed up are closed and not in use by programs running in
other windows. If Backup is performed on an open file, for example, LETTER,
the copy of LETTER on the backup diskette will have a length of zero. If
you later restore this diskette, any existing LETTER file will be
destroyed.

~Subhead~ When You Use DOS Extended Programs

 DOS Extended programs run in Protected Mode and may therefore require you
to do some special setup of the program's DESQview information file and
possibly your memory card. You may also need to modify your QEMM-386
command line if you are using QEMM-386.

 If you are running DESQview 386, QEMM-386 will manage the memory for you
because it supports VCPI (Virtual Control Program Interface), which handles
the co-existence of both exTENDed and exPANDed memory. If you are using a
386 memory manager other than QEMM-386, you cannot run DOS Extended
programs (inside or outside of DESQview) unless the memory manager you are
using supports VCPI.

 In your QEMM-386 command line do NOT use the FRAME=NONE parameter or the
NOEMS parameter if you want to run DOS Extended programs.

 If you are running DESQview on a 286 machine,  set up your memory board to
configure the proper amount of exTENDed memory to run your largest DOS
Extended program as well as the quantity of exPANDed memory required to run
your regular DOS programs.

 Many VCPI programs, like many programs which use exPANDed memory, will use
all available memory if you let them. You can limit their use of  memory by
entering a value in the Maximum Expanded Memory field of the Change a
Program menu. (This option will limit exTENDed memory for a DOS Extended
Program.) Unfortunately,  even this will not prevent some DOS Extended
programs from using all the memory it can find. Such a program may well
have its own method, such as a command line parameter, of limiting the
amount of memory the program will use.

 If you use the Close Window command or Ctrl-Alt-Del to abort a DESQview
window, the memory a DOS Extended program was using may not be released
(until you reboot your computer). To free up memory, be sure to use the
program's own termination commands to close the DESQview window. You may
also wish to set the Allow Close Window command option to N (No) in the
Change a Program menu to be sure that the program's window cannot be closed
without terminating the program.

 Finally, DOS Extended Graphics programs cannot be virtualized, some of
them not even in Text mode. So, be sure the Virtualize text/graphics option
is set to N (No) ~dash~ or T (Text) if the latter does happen to work for
that particular program.

~Heading~ Display Problems

 This section discusses how to solve common problems related to the
information that's displayed on your video display screen.

~Subhead~ If a Curtain Suddenly Covers Up Your Screen

 If a mesh-like Curtain appears over the graphics information on your
screen when you tap the DESQ key, nothing is wrong. DESQview just can't
display the graphics and whatever else you may be trying to display at the
same time. The graphics information is still intact but just can't be seen
simultaneously with information in other windows. It will reappear when you
switch back to the program.

 There can be serveral reasons why DESQview may have invoked the graphics
curtain:

~Item~ You may have had the Do you want Text and Graphics Displayed at the
Same Time? option in Setup set to N.

~Item~ The program which displayed the graphics information may be using a
display mode that DESQview doesn't fully support. Because DESQview doesn't
support the mode the program was using to display information, DESQview
can't display its menus, or let other programs run in this mode.

~Item~ There may not be enough exPANDed memory to save the graphics screen.

~Item~ If you are using DESQview 386 and you have the QEMM parameter PAGE=0
and there is not enough system memory to hold the graphics screen, it
cannot be displayed when you switch away from it.

~Item~ There may be two graphics programs on the screen in different modes
and DESQview can't display them both in the same mode.

 Also see Advanced Option: Video Monitor, Appendix A.

~Subhead~ If the Screen Suddenly Switches from Color to Black and White

 This problem only happens if you have Virtualize text/graphics turned ON
(Y) and using a color/graphics (CGA) display adapter board, and only when
the program you're running switches into graphics mode. When this happens,
DESQview responds by switching to black and white so it, too, can display
menus and other windows in graphics mode. There are various CGA modes we
could have used; we chose black and white because it has the best
resolution. The screen can only be in one mode. So, when a program switches
modes, any other visible windows must switch modes as well, or be hidden by
the graphics curtain.

 If you switch to another program while the screen is still in graphics
mode, the window you switch to will be in black and white, even if that
window is normally in color. The only way to restore color is by removing
the graphics window from the screen. You can switch the graphics program
back to text mode (if possible), hide or put aside the program, or close
the graphics window.  (Hiding the window is usually the easiest way.)

 You can prevent this problem from happening by running the Setup program
and specifying that you don't want text and graphics displayed at the same
time (see Appendix A).

~Subhead~ If an EGA or VGA Suddenly Changes Its Colors

 The enhanced graphics (EGA) and Video Graphics Array (VGA) display
adapters, while greatly improved over previous graphics adapters, still
limit the number of colors that can be displayed at one time. To increase
the total number of possible colors, the EGA and VGA allow programs to
define and switch between color palettes (groups of colors).

 To maintain a consistent user interface, DESQview wants its own menus (and
other visuals) to always be displayed in their normal colors ~dash~ which
you can configure (see Appendix A). So, when you tap the DESQ key, DESQview
changes the palette to the normal one for DESQview with the result that the
colors of other windows may change. This is temporary and harmless.

 As soon as you switch back to the program, its normal color palette will
be restored. With VGA adapters, the palette is saved and restored on modes
DESQview supports (See page 126) with EGA this is not always possible,
particularly if the program writes directly to the screen.  If you are
experiencing a palette change you do not like in a window that is active,
you may change the colors from the Rearrange menu, or use the DESQview
Palette program. See pages 57 and 131 for more information on these
options.

~Subhead~ If a Program Bleeds Through Into Other Windows

 If a program bleeds through (shows through) into other windows, or leaves
bits of text lying around in odd places on the screen, it's most likely
that the program writes directly to the screen rather than going through
DOS or the ROM BIOS. To determine if this is the case.

~Step~ Run Change a Program for the program and check if the Writes text
directly to screen option is turned OFF (N).  If it's not, turn it OFF.
Also, turn Virtualize text/graphics OFF (N), and make sure  Starting
Height, Starting Width, Starting Row and Starting Column are blank.

~Step~ Start up the program again, paying close attention to what happens
on the screen. DESQview will first open a small window on the screen and
the program will begin to load.

~Step~ If the window frame is overwritten when the program starts up, the
program does, in fact, write directly to the screen. Run Change a Program
again and turn the Writes text directly to screen option ON.

 When you turn ON the Writes text directly to screen option, the Runs in
Background option is also turned OFF (logically) for 8088, 8086, 80286
computers and for 80386 computers where the program is not virtualized- if
it's been left blank.  Normally, this is what you want. Sometimes, however,
it's desirable to let a program that writes directly to the screen run in
background. For example, if your database program sorts for an hour without
writing on the screen, then writes DONE, it might be worth tolerating the
fact that DONE bleeds through to get the advantage of sorting in
background.  If you are running DESQview 386 you can virtualize programs
which write text directly to the screen and graphics programs (which always
write directly to the screen. (See page 117 and Appendix K, More About
Virtualization) )

~Subhead~ If Part of Your Graphics Screen Disappears or Becomes Garbled

 If your switch away from a program that's displaying graphics information
and then, when you switch back, you find that part of your video
information is missing or garbled, run Change a Program on the program and
be sure that the Displays graphics information option is turned ON. If the
problem persists it may be because:

~Item~ The program is using more than one page of graphics memory. Run
Change a Program and try setting Graphics Pages to 2 or higher (see page
122).

~Item~ You are not using the most current versions of the necessary video
driver.

~Item~ You didn't give DESQview the correct setup information at
installation. Run the Setup program (see Appendix A) and verify that the
Video Monitor option correctly specifies the type of display adapter board
you are using and selects the correct Current Graphics Driver.

~Item~ Your video adapter is using autoswitching. Disable autoswitching on
your video adapter card.

~Item~ The program is using a graphics mode not fully supported by
DESQview. In this event, the only way to keep the screen image from
becoming damaged when you switch away is to switch into text mode, or into
a graphics mode that DESQview does support, before you tap the DESQ key. If
the program doesn't permit either of these two options, there may not be a
way to have the screen restored correctly by DESQview. However, the program
may have a redraw command that you can use to restore the screen when you
switch back. If you configure the program, via its own ~dash~ not
DESQview's ~dash~ setup procedure to run in a more generic video mode which
is supported by DESQview, it will run in DESQview.

~Subhead~ If Your PC Slows Down When You Mix Text and Graphics Windows

 When you switch between two programs, one of which is working in text mode
and one of which is working in graphics mode, DESQview tries to avoid
switching video modes by displaying text information in graphics mode.
Converting text to graphics, however, is computationally intensive and may
thus slow down the text program. If this is a problem:

~Item~ You can tell DESQview never to mix text and graphics by running the
Setup program and turning OFF the Do you want text & graphics displayed at
the same time? option (see Appendix A).

~Item~ You can use the Hide command to remove the graphics window from the
screen before you switch away from it.

~Heading~ Helpful Hints


 This section offers some general hints about the things you often want to
know about as you become more familiar with DESQview.

~Subhead~ How to Figure Out How Much Memory You Have Available to Run
Programs

 To determine exactly how much unused memory you have left to run programs
without having to swap a program, use the Memory Status program (see
Appendix B).  Be sure to follow the instructions that explain how to
compensate for the size of the Memory Status program and amount of DESQview
overhead a program needs.

~Subhead~ More about the Amount of Memory a Program Needs

 To figure out how much memory a program needs, first check the program's
installation manual.  If it gives you a memory size, subtract out the size
of DOS, about 60K.  If the manual doesn't give a size, you can make a good
guess by adding together the size of the program.COM or program.EXE file
that starts up the program and the size of the largest overlay file.

 If the program keeps a lot of data in memory (1-2-3, Symphony, Framework
III, Multiplan, and so forth), add at least 5K-10K for a minimum data area.
If you know you'll be working with large amounts of data, add more.  It's
always better to start with too much memory and then reduce it since, with
too little memory, you may have problems getting the program to run. Also
see If a Program Won't Start Up on page 194).

~Subhead~ How to Run Very Large Programs.

 When using large programs (CAD, Desktop Publishing, etc.) in DESQview, it
is usually necessary to give the program as much memory as possible. (See
Appendix B for a discussion of what kind and how much memory you need for
your computer.) You get maximum memory available for programs when you use
the XDV program to start DESQview (see Installation Notes for an
explanation of DV.COM). Second, when installing the program in DESQview,
set the memory sizes as follows:

 Program Memory Size (in K): 450Maximum Program Memory Size: 800

 This setup will guarantee at least 450K for the program. Then, DESQview
will allocate as much more memory as it can. In some cases, you may find it
useful to force a program to "swap" using Rearrange/Put Aside in order to
free enough memory to run another large program.

~Subhead~ How to Install Several Versions of the Same Program

 You may install as many versions of the same program in DESQview as you
want. To create a new Open Window entry from an existing entry, run Change
a Program and modify Keys to Use on Open Menu.  When you modify this field,
DESQview creates a new entry, with the new keys you specified, and also
retains the original entry.

 For example, you could install a 256K, a 400K, and a 512K version of 1-2-3
Release 2, or a character mode and a graphics mode version of Microsoft
Word. Given that you've already installed the standard 256K version of
1-2-3 (2x), to create a new version:

~Step~ Display the Change a Program menu for 1-2-3. Change Keys to Use on
Open Menu to different letter.

~Step~ Make any other changes you want.  We recommend you also change
Program Name so you can tell the different entries apart. For example, to
create a 400K version of 1-2-3, change Keys to Use on Open Menu to L4,
Program Name to Lotus 1-2-3 (400K), and Memory Size (in K) to 400. Also see
page 198, When You Run Several Copies of the Same Program Simultaneously.

~Step~ Select DONE to create a new entry on the Open Window menu.

~Subhead~ How to Start Up a Program Full-Screen

 When you install a program listed on the Add a Program menu whose Writes
text directly to screen option is turned OFF (meaning that it can run in a
small window), DESQview will configure the program to open in a small
window. To make it open in a full-screen window instead, display the Change
a Program menu and set Starting Height/Width/Row/Column to 25,80,0,0.

~Subhead~ How to Open a Program in 43 or 50 line Mode

 You can force a program to open full screen and in the 43 or 50 lines
supported by your video adapter by setting Starting Height to the number of
lines desired for text modes of EGA or VGA adapters. Setting this value
will cause DESQview to switch the display to the proper mode when the
window is opened, as well as when you switch back to it. For programs with
Writes text directly to screen set to N, you must also have Uses its own
colors set to Y. Both Starting Height and Maximum Height values should be
set to 43 for EGA and 50 for VGA.

~Subhead~ About Files named DESQTMP?.*

 DESQview treats file names whose first seven characters are DESQTMP in a
special way: such files are always read or written to the drive and
directory from which you start up DESQview (most commonly, C:\DV)
regardless of any drive or directory you specify.  This allows two
programs, running in different directories, to exchange information.

 For example, if you're running 1-2-3 in the LOTUS directory and
WordPerfect in the WORDPERF directory, you could transfer a file from 1-2-3
to WordPerfect without regard to directory usage:

 Use the 1-2-3 Print command to print the information you want to transfer
to a file named DESQTMP.PRN.

 Then, switch to WordPerfect and read in DESQTMP.PRN as an ASCII text file.

 You can generalize this capability by creating a set of generic transfer
scripts.  For example, say you want to be able to transfer text files
between 1-2-3, MultiMate, and R:BASE, in any combination. Using the DESQTMP
feature, you would create, for each program, a script that writes out a
text file to DESQTMP and a script that reads in a text file under this
name. Now, you can transfer information between these programs without any
concern about directory or the file naming conflicts.

~Heading~ Program Specific Information

 This section discusses some important information you should know when you
run certain programs in DESQview.

~Subhead~ When You Run Lotus 1-2-3

 When you start up a program in DESQview, DESQview determines how much
memory it requires by examining the program's DESQview Program Information
File (DVP).

 For 1-2-3 and other programs that keep large amounts of data in memory the
default memory size provided by Quarterdeck allows for only a small, one-
or two-page spreadsheet. If you intend to work with large spreadsheets, you
should increase the memory size by changing Memory Size (in K) on the
Change a Program menu (see page 120).

 The amount of memory a single 1-2-3 screen occupies depends on what's on
that screen. However, a rough rule of thumb is that an average screen of
data uses about 2K-3K of memory. If you already have a worksheet file
(xxx.WKS), the approximate amount of memory required to load it is the size
of xxx.WKS plus 100K (version 1A) or 180K (version 2.0). Spreadsheets in
Release 3 tend to take up twice as much memory as in Release 2.

 Lotus 1-2-3 Release 3 incorporates a DOS extender  which complies with the
Virtual Control Program Interface (VCPI), a specification which Quarterdeck
coauthored along with Phar Lap Software. To run Release 3 optimally in
DESQview, follow these guidelines:

 Be sure to use the exTENDed memory manager appropriate for your system
~dash~ QEMM (preferably) for 80386 systems or QEXT for an 80286 or an
80386.

 Running Version 3 in a Small Window. In order to run Release 3 in a small
window or in the background, you must have an 80386 machine with QEMM-386
installed. You can run Release 3 in graphics mode on EGA and VGA displays,
however DESQview 386 cannot virtualize protected mode graphics. However,
if you have an EGA or VGA adapter, Lotus' default configuration will run
1-2-3 in graphics mode for both graphic display and text display. 1-2-3
must be in text mode if you wish to virtualize it.  DESQview 386 cannot
virtualize protected mode graphics as it can standard DOS graphics.

 If you want Release 3 to run in a small window, configure a video driver
set that looks for both a CGA driver and an EGA or VGA driver. Please see
Chapter 3 of the Lotus 1-2-3 Release 3 Setting Up booklet and the section
Specifying Your Equipment. Creating alternate video driver sets will enable
you to change the video mode as needed to run 1-2-3 either in a window or
full screen only.  The important thing to remember is, if you want 1-2-3 to
be virtualized, use the Lotus CGA driver as the default setup. If you do
this, Lotus will display worksheets in text mode and can thus be
virtualized. (Graphs can only be displayed in graphics mode, consequently,
they cannot be virtualized.) See Appendix K, More About Virtualization.

 The CGA driver will run the standard spreadsheet display in text mode,
which can be virtualized.  Since Lotus allows you to switch video drivers
on the fly by typing "/", "W(orksheet)", "W(indow), "D(isplay)", and
selecting a driver, it is possible to start with a default graphics or text
display and switch the display when you need graphics, or want windowing
capabilities.

~Subhead~ When You Run Sidekick or Sidekick Plus

 You can load Sidekick before you start up DESQview (possible, but not
recommended) or in a DESQview window but not both. We recommend that you
run it in a DESQview window (see page 197, When You Run Memory-Resident
Programs).

 If you have Sidekick configured to the maximum Notepad size (50K), you
must run Change a Program and increase Memory Size (in K) to 128K (see page
120).

 We also recommend that you run the Sidekick installation program
(SKINST.COM) and change the primary Activate key sequence from Alt to
Left-Shift/Right-Shift. This will avoid conflicts with DESQview's use of
the Alt key as the DESQ key.

 SideKick Plus also be run in a DESQview window and with the /G parameter,
which makes it non-resident. After bringing up SideKick Plus with the
activate key and opening a utility, you can bring up the SideKick Plus menu
by holding down the Alt key for several seconds. If you let go of the Alt
key before making a selection, the DESQview menu will come up.  This is
normal, since this is the DESQ key. If you press Esc at that point, you
will go back to SideKick Plus. If you wish to change this, you must
redefine the DESQview key, since there is no way to redefine this usage for
SideKick Plus.

 If you wish to run SideKick Plus in a window under another program, you'll
need to make a batch file that first runs Sidekick Plus and then the  other
program.  You will need to allocate enough memory for the program plus nnK,
where nn is enough to cover the resident overhead of SideKick Plus. In
general, SideKick or SideKick Plus will be much faster if you load it in
its own window and use DESQview for your switching.

~Subhead~ When You Run Microsoft Word

 DESQview only supports Word version 2.0 and above. The default DESQview
Program Information File (DVP) for Word version 4 and below starts up Word
with the /C parameter which causes the program to run in character mode.
If you prefer to run Word in graphics mode (and your system has a graphics
display adapter board), your must run Change a Program and delete /C or
replace /C by the mode parameter you want in the parameters field (see page
114)  It is also a handy option to place a ? in the parameters field, which
will pause before the program is executed and allow you to enter your own
parameters for video mode or a path and file name to load.

 You can use DESQview's Mark feature to mark text in a Word window when
Word is in character mode but not when it is running in graphics mode.

~Subhead~ When You Use the DOS Check Disk (CHKDSK) Command

 Never use CHKDSK with the /F parameter in a DESQview window unless you've
first closed all the files in all other windows.  Programs often create
temporary files when they're running.  CHKDSK /F may collect and destroy
these files.

 CHKDSK can be safely used without the /F parameter.  But, the bytes total
memory value will be incorrect and the bytes free value will indicate the
number of free bytes in the current window only not the total remaining
memory available to load programs.  The various disk space values will be
correct.

~Heading~ Operational Problems

 This section discusses how to solve common problems that may occur while
you are running DESQview.

~Subhead~ If DESQview Hangs Unpredictably

 Properly configured, DESQview is a very stable and reliable system.
However, if you find that DESQview seems to hang at unpredictable times, it
may be due to one of these problems:

~Item~ Memory-Resident Programs.Memory-resident programs and device
drivers, especially those loaded before you start up DESQview, are always
the first thing to suspect when you're encountering unpredictable system
hangs.

 To determine if one of these problems is causing the problem, remove all
of them from your AUTOEXEC.BAT or other startup batch file.  Then, try
running DESQview again. If the problem goes away, put them back, one by
one, until you determine which program is at fault. Sometimes, you will
also find that loading the programs in a different order will make a
difference.

 If at all possible, we recommend that you run your memory-resident program
inside DESQview windows.  DESQview has much more control over such programs
running in windows than it has over the same programs loaded before you
start up DESQview.  Not all memory-resident programs are effective in
windows, but many are.  Also see When You Run Memory-Resident Programs on
page 197.

~Item~ Memory Problems. Hardware or memory problems can also be the source
of system hangs. When you run DESQview, you may start using portions of
high memory that weren't being used before.  Also, DESQview may exercise
interrupt vectors and other standard hardware features that your normal
programs don't.

 If your system ever hangs with Parity Check displayed on the screen, you
should suspect a hardware error. If you think you may have a hardware or
memory problem, we recommend that you run the diagnostic program that comes
with most PCs or, consult your dealer or service technician.

~Item~ Expanded Memory Board. If you're using an exPANDed memory board,
recheck the switch settings on the board to verify that it's properly
installed. In particular, take care that the memory supplied by the
exPANDed memory board doesn't overlap memory addresses already filled by
motherboard memory or by an add-on memory board.

 If you're using an exPANDed memory (EMS) board, be sure that the exPANDed
memory manager (EMS driver) you're using is compatible with EMS version 3.2
or later. DESQview can't be depended upon to operate properly with an
earlier version. Consult the memory board's manufacturer for up-to-date
information.

~Subhead~ If DESQview Hangs When You Switch Windows

 If DESQview hangs when you switch windows, it's most likely that the
program you switched away from had too little memory allocated for it. See
If Starting Up a Program Hangs DESQview on page 194.

~Subhead~ If Expanded Memory Seems to Disappear

 If you have an exPANDed memory board installed, and find that all of your
exPANDed memory suddenly seems to become unavailable, most likely you are
running a program that immediately grabs all available exPANDed memory when
it starts up, such as Paradox, FoxPro or Quattro. Once a program takes all
the exPANDed memory for itself, it can't be used by anything else, until
the program gives it back which, most likely, won't happen until you close
it down.

 To determine if this is the case, run the Memory Status program (see
Appendix B) and note the Total Available Expanded Memory value. Then, one
at a time, open each program that uses exPANDed memory.  After the program
starts up, switch to the Memory Status window and check the Total Available
Expanded Memory value again. When it drops to zero, you've found the
program (or, at least one of them) that's grabbing all your exPANDed
memory.

 To solve this problem, you can limit the amount of exPANDed memory a
program can have by running Change a Program and setting a Maximum Expanded
Memory Size (in K) value for the program to something reasonable. You may
need to experiment to find the optimum exPANDed memory under DESQview for
that program.

~Subhead~ If Your PC Beeps or Clicks on Every Keystroke

 If your PC suddenly starts beeping every time you press a key, almost
certainly you've forgotten to finish a script you started earlier.  (The
beeps signal that you've filled up the Learn Scripts buffer see Chapter 5.)
Cancel the script by displaying the Learn menu and selecting Cancel.

 If you were really creating a script, you need to increase the size of the
Learn Scripts buffer and probably also change Script Buffer Size (see page
125), if you're learning the script for a program, or the DESQview Scripts
buffer size, if you are learning a script on the DESQview menu.

 The keyboard may also be beeping if you have run out of exPANDed memory or
if you try to type to a small window which is not virtualized (DESQview
386). If you designate a program as virtualized, and it appears that it is
not being virtualized, you probably do not have an alternate map available
(see Appendix K, More About Virtualization and the the Technical Notes
followingAppendix B).

 If you hear a click every time you press a key, you are probably learning
a script. If you display the Learn menu, it will indicate "Learning." If
this is not what you wanted, Cancel the Learn. (When you display the Learn
menu again it will indicate "Not Learning.")

~Subhead~ If You Can't Close a Window or Quit DESQview

 It's possible to configure a program so that the Close Window command is
inoperative by turning OFF the Allow Close Window command option. This can
be desirable because it completely eliminates any possibility of
accidentally closing the window and possibly losing unsaved work. The only
way to close the window, in this case, is by using the program's quit
command. (Programs written expressly for DESQview may also disable Close
Window.)

 If any windows disallow the Close Window command, the Quit DESQview
command is disabled until all such windows have been terminated, again, as
a safeguard against accidentally losing data or damaging files by a
mis-typed keystroke sequence.

 If a program that normally closes its window on exit encounters an
abnormal end or termination with error, it may leave the window open.  This
can be useful, because any error message generated by the program or by DOS
will be visible. To close the window, you can type EXIT, or use the close
window command if permitted. Ctrl-Alt-Del will also close a foreground
window (unless your keyboard is locked).

~Subhead~ If File Operations Under DESQview Seem Slower

 DOS performs file operations using a technique called direct memory access
(DMA) that allows two different pieces of hardware to access memory
simultaneously. For file operations, this allows the processor to continue
to run programs while the disk controller performs the file operation in
parallel.

 However, exPANDed memory isn't compatible with the DMA hardware. So, when
a program running in exPANDed memory performs a DOS file operation,
DESQview intercepts the DOS command and tells DOS to perform the command
using real (conventional) memory instead.

 DESQview initially allocates a 2K area of conventional memory for such DMA
operations.  If DOS file operations in DESQview seem to be slower than
outside of DESQview, it may be that this area is too small. To increase its
size, run the Setup program and change DOS Buffer to EMS (see Appendix A).
Try increasing it in 2K-3K increments. There's little value in increasing
it beyond 30K. Increasing DOS buffers for EMS will reduce your maximum
program size, but will improve disk performance.

~Subhead~ If you find SWAP????.DV files on your hard disk

 Whenever you quit DESQview normally, it will automatically erase any
"swap" files from your hard disk. Swap files are written to disk if you
specified a swap disk (rather than swapping to exPANDed memory or a RAM
disk) in Setup ~dash~ or if there were not enough room in exPANDed memory
or on the RAM DISK (See Appendix A).  If you exit DESQview abnormally, such
as with a system failure or by turning off the computer without exiting
your programs or DESQview, you may find SWAP????.DV files (where ???? stand
for random characters) on your hard disk. Depending on the amount of space
needed to save a program's environment when it is swapped out, these files
can be quite large. You should delete any SWAP????.DV files from your hard
disk. They cannot be used for any program or data recovery.

~Heading~ Performance Considerations

 This section discusses how to solve common problems  that may affect the
performance of DESQview or of programs running in DESQview.

~Subhead~ How to Optimize Your PC's Performance

 DESQview provides multitasking of existing programs by a technique called
time-slicing. Under this technique, DESQview runs each program, in turn,
for a fraction of a second. To the user, however, the effect is that
multiple programs are running simultaneously.

 Initially, DESQview assumes that it should optimize performance in favor
of the program running in the current window the foreground program by
giving it a larger slice of time than it gives to background programs.
However, you can control the amount of time allocated to foreground and
background programs.

 You can optimize performance in favor of the foreground or the background.
Optimizing in favor of the foreground means minimizing the amount of
background processing. Optimizing in favor of the background means
maximizing the amount of background processing while still allowing enough
time to work on simple tasks in foreground comfortably.

 There are four ways you can control how a program runs in background. You
can:

~Step~ Press Ctrl-NumLock (or use the Freeze command) before switching away
from each program to prevent it from running in background temporarily (see
page 40).

~Step~ Configure each program so it doesn't run in background at all by
turning OFF its Runs in Background option.

~Step~ Run the Setup program and change the balance of time allocated to
run programs so that the foreground program gets a greater percentage of
the overall time available and the background programs a smaller
percentage, or vice versa.

~Step~ Use the Rearrange/Tune Performance menu to reset system and window
clock ticks.

 The method you choose depends on whether the problem is short-term or
long-term:

 Pressing Ctrl-NumLock and using the Tune Performance menu is for
spur-of-the-moment control.

 Turning OFF the Runs in Background option affects that particular program
every time you run it, but no other programs.  This helps by preventing the
program from interfering with other background processes whenever it's
running.

 Changing the balance by running Setup affects the overall performance of
your system. If you decide to do this, be sure to read the discussion in
the Advanced Option: Performance section of Appendix A about allocating
clock ticks.

 In deciding what method to use, be aware that programs that appear to be
doing nothing in background often are doing quite a lot. For example, even
though a program is just waiting for your next command, it's probably
polling the keyboard and consuming at least a small amount of time. At the
other extreme, Lotus 1-2- 3 continuously checksums you data (to maintain
data integrity) while it's waiting for the next keystroke. So, even though
nothing appears to be going on when you switch away from 1-2-3, it's
actually working quite intensively and using up lots of background time.

~Subhead~ How to Optimize the Swapping of Information Out of Memory

 To allow you to load more programs than will actually fit in memory at one
time, DESQview supports virtual memory. By this we mean that, when you try
to start up another program, and there isn't enough memory available to
load it, DESQview tries to accommodate you by interrupting (suspending) one
or more of the programs currently running, moving them to hard disk, RAM
disk, or exPANDed memory, and then loading the program you requested.

 This is a very powerful feature of DESQview. It allows you concurrent
access to a group of programs whose total memory requirements may be far in
excess of the normal 640K limit. However, there are two drawbacks to
virtual memory:

~Item~ Programs that must be swapped out cannot continue to run.

~Item~ The time it takes to perform the swap is highly dependent on the
speed of the media used with hard disks being the slowest, RAM disks being
much faster, and exPANDed memory being almost instantaneous.

 Bearing these factors in mind, the following discussion is intended to
give you some guidelines for eliminating or speeding up swapping on your
system.

 Load your largest program first. This is because the window you can open
in Conventional Memory is larger than a window you can open in ExPANDed
memory. However, if you use ALL the conventional memory for your first
program, or a subsequently opened program uses the remainder of your
conventional memory, you won't be able to open any more programs. The
Memory Status program will tell you how much of each kind of memory you
have left.  You should set the memory size for each program to somewhat
less (usually about 7-9K) than what Memory Status shows as the largest
available amount of the kind(s) of memory your program will be using.

 To Eliminate Swapping: The only way to eliminate swapping, without
disabling it altogether, is to be sure that all the programs you intend to
run can fit in memory at the same time. (See the table at the beginning of
Appendix B for information on the approximate maximum memory sizes you can
expect for different types of PCs.)

 You can disable swapping altogether by running the Setup program and
turning OFF the Allow Swapping of Programs? option.

 (See Appendix A.)You can disable swapping temporarily ~dash~ for a
particular window or for all windows ~dash~ from the Tune Performance menu
(See page 54).

 To Reduce Your Memory Usage: Be sure that you're not allocating more
memory to your programs than they actually need to run properly by using
Change a Program to check the Memory Size (in K) value.

 Load memory-resident programs in a DESQview window, if possible

 Consider adding an enhanced exPANDed (EMS4) memory board or upgrade card
with an 80386 processor to your system. Both of these options let you break
the 640K barrier and run multiple, large programs concurrently. (See
Appendix B.)

~Subhead~ Speeding Up Swapping.

 If all your programs simply can't be made to fit in memory at the same
time, and must be swapped, you can reduce swapping time by configuring your
machine to swap to the fastest media available. This is controlled by how
you've configured SWAP Drive. See Appendix A for more detail, but
basically:

~Item~ If you leave the SWAP Drive field empty, DESQview swaps to exPANDed
memory, if you have exPANDed memory. If you don't (or don't have enough
available), it then swaps to the root directory of the hard disk on which
you installed DESQview.

~Item~ If you specify a SWAP Drive to use, DESQview always swaps to that
drive unless there's not enough space available, in which case it swaps to
the directory of the hard disk on which you installed DESQview.  If there
is not enough disk space there, you will get an error message and swaping
will not occur.

~Item~ If you have a RAM disk and wish to use it as a swap drive, you must
run Setup, choose Logical Drives and enter its drive letter in SWAP Drive
before DESQview will use it. The program most commonly used to create a RAM
disk is VDISK, which comes with most versions of DOS.

~Item~ If you are swapping to the RAM disk, you need to be aware of how
much virtual disk space you'll have available for swapping, if you've
copied any program or data files there. This will be different for every
progam, but basically it will be the amount of memory the program and the
data use plus the amount of memory needed to store the video information
(video memory can be as much as 256K).

~Subhead~ Swapping Communications Programs.

 Communications programs should have the Can be swapped out of memory
option turned OFF, as a rule.  You may however, if you must, manually swap
a communications program out if it is not actually engaged in
communications. If you observe the following caveat, you may even allow
another program to use the same COM port while the first is swapped:

 When a Communications program is swapped back in, it will remember which
port it is connected to. If, while it was swapped out another program
reinitialized the COM port in a different way (for instance a different
baud rate), the first program will probably fail. If you wish to use the
same COM port for two or more programs which will be swapped, you must make
sure that both programs initialize it the same way.

~Heading~ Keyboard and Learn Problems

 This section discusses how to solve common problems related to using the
keyboard or to using DESQview's Learn feature.

~Subhead~ If the Cursor Keys <Right Arrow>,<Down Arrow>,<Left Arrow>,<Up
Arrow> and/or Home, End, PgUp, PgDn Suddenly Stop Working

 If the Cursor keys suddenly appear to stop working, and you don't have a
mouse installed on your system, you've most likely turned ON the keyboard
mouse inadvertently. This happens whenever you tap the Ctrl key quickly.
You can tell if you've done this by looking for the mouse cursor, a white
diamond. If the arrow keys move the mouse cursor, just tap the Ctrl key
again to turn the keyboard mouse OFF.

 If you find this is to be a chronic problem, you can disable the Ctrl key
(see Appendix A). However, if you do this you may not be able to move or
resize windows for programs written expressly for DESQview. A better choice
would be to redefine the key for the keyboard mouse to something that is
unlikely to be hit accidentally, such as Alt-Ctrl.

~Subhead~ If DESQview Won't Let You Learn a Script on the Key You Want

 Not all keys, or combination of keys, are legal in the sense that the ROM
BIOS recognizes them. The enhanced PC keyboard recognizes more keys than
does a PC-XT or a PC-AT keyboard, but no keyboard recognizes all possible
key combinations.  For example, no standard keyboard recognizes Ctrl-Esc or
Ctrl-Alt-X.  Also, some system keys, although recognized, can't be
redefined for example, Ctrl-NumLock, Pause, Print Screen, SysRq, and so
forth.

 If nothing happens when you respond to the Press the Key You Want to
Redefine message, that key or key combination cannot be redefined (also see
Appendix I).

~Subhead~ If a Script Only Plays Back Part of the Keystrokes You've Learned

 If a script plays back only part of the keystrokes you've learned, there
are several possible reasons:

~Item~ The program doesn't allow type-ahead. some programs throw away
keystrokes if you type them too quickly, or while the program is performing
a long operation, for example, reading a file.  Experiment by typing the
keystrokes that are being lost to the program very quickly yourself.

 If this seems to be the problem, run Change a Program and set the Keyboard
conflict level to a higher number. Different settings of Keyboard Conflict
have different methods of handling keystrokes. See page 131 for a more
complete description of how to determine the correct Keyboard Conflict
level.

~Item~ The keystroke sequence isn't supported by Learn. Learn can only
learn legal keystrokes (see page 211, If DESQview Won't Let You Learn a
Script on the Key You Want, and Appendix I). If your program allows illegal
(to DESQview) keystrokes (because it bypasses the ROM BIOS and manages the
keyboard itself), the program will still work correctly in DESQview, but
those keystrokes won't be recorded as part of a script much as mouse clicks
aren't recorded.

~Item~ The program is clearing the keyboard buffer.  Some programs
arbitrarily discard anything that's been typed ahead at certain times, for
example, after an error has occurred. If this happens when a script is
being played back, all the keystrokes after this point will be lost. The
best solution to this problem is to use the Time Delay command to give the
program time to get back in a state where it's ready to read keys again.

~Subhead~ If a Script Goes Into a Loop

 Be sure that, when you learn a script, you don't use the key to which you
assigned the script in the script itself. If you do, the script will go
into a loop when you play it back which is to say, it will play itself over
again and again until you press the Ctrl-Break key to stop it.

~Item~ You can override a key redefinition by using `, the Learn quoting
character. In this case, it's okay to include the redefined key in the
script. For example, you could redefine the Ins key to ring the bell
(Ctrl-G) and then pass the Ins key as it's actual value by: {Ins}={^G}
`{Ins}.

~Subhead~ If Learn Won't Work with a Program

 If you start a Learn, but the script you create doesn't do anything when
you play it back, the program that you learned the script for may bypass
the DOS keyboard mechanism and read the keyboard directly. (Other keyboard
enhancers such as ProKey, SuperKey, and so forth, also won't work with such
a program.)

 Some programs can be set up to be compatible with keystroke enhancers.
Check your program's manual to see if it can be.  If so, this will probably
make it work with DESQview Learn. If not, there's nothing you can do to use
Learn.

 Notes:

~Heading~ Command Line Switches

The following DESQview command line switches should be used with caution.
They are for remedial use only and to experiment with them for usage other
than the documented purpose may be inviting problems. If one or more
command line switches apply to your particular problem, try them one at a
time to see if they help.

 The switches should be placed after the command you use to start DESQview.
You may use the entire string or the abbreviation which follows it (without
the parentheses). The slash (/) is required syntax in either case.

 /NOSETUP (/NS) This switch causes DESQview to ignore the DVSETUP.DV file
(which contains all of the information provided by the DESQview Setup
program). Without the setup file, no graphics driver is loaded and no mouse
is supported and all other Setup options are set to their most innocuous
values. It is used mostly to diagnose startup errors.

 /OLDKEYBOARD (/OK) This switch tells DESQview to make the old-style
interrupt 16h test/wait-for-input calls (functions 0, 1) instead of the
new-style calls (functions 10h, 11h) to get its keys. This is necessary for
a BIOS that erroneously claims it supports the new keyboard calls. It is
also necessary for compatibility with keyboard enhancers and keyboard
monitors that don't support the new calls.

 /LOCKOUTDISK (/LD) This switch helps avoid "Disk Drive Not Ready" errors
for certain hard disk controllers. It disallows task switching during the
entire time an INT 13h (disk request interrupt) is running.

 /DOSTERM (/DT) This switch lets DOS do the terminating of applications. By
default, DESQview terminates applications without calling DOS to do it.
This is considered consistent since we don't let DOS load programs unless
you specify it. However, some networks and TSRs can't keep track of
programs if they see a terminate without a corresponding load. Some DOS
utilities (most notably SHARE) and some networks won't be able to keep
track of programs if they don't see terminates. Try this switch if you are
getting sharing violations or if files which would normally be closed are
left open when a program terminates.

 /CODEVIEW (/CV) This switch causes DESQview to be more compatible with the
Codeview debugging environment. It has the following effects:

 DESQview will return keys to interrupt 16h  requests even if the task
making the request has an open keyboard object in a window above it.

 When a program waits for input and no keyboard input is pending, DESQview
will PAUSE and retry, rather than stopping the program.

 DESQview will allow video BIOS calls for background windows to go through
to the BIOS, rather than handling them itself.

 All these behaviors are inconsistent with the standard
DESQviewenvironment, but are necessary to let Codeview debug multi-window
programs.

 EXCLUDE=mmmm-nnnn (/X=mmmm-nnnn) This switch takes a segment range (in
hex) to exclude from use by XDV. It is necessary if the exPANDed memory
manager has allowed other programs to map any pages which conflict with
some device in the system. Preferably, to correct this, the pages should be
excluded from use by the exPANDed memory manager when it is loaded in
CONFIG.SYS, rather than from XDV at run time. If your memory manager
excludes the area of memory, then no other software can ever map any memory
to the excluded area. (It's reasonable to assume that if XDV shouldn't map
there than nothing else should, either, however you may not have
encountered anything else causing a conflict until you ran XDV. This
doesn't mean that nothing else ever will.) Also, it will always be excluded
from DESQview as well, no matter how XDV is invoked.

 /LIST (/L) This switch causes XDV to list out the areas into which it is
loading DESQview, and how much of DESQview is being loaded into each area.

 /GENERICEEM (/EE) This switch forces a Quarterdeck exPANDed memory driver
to use EEMS calls to talk to Rampage boards. By default we talk directly to
the ports (which is much faster) if a pre-EMS 4 driver is loaded on a
Rampage board.  However, some disk caches and other EMS TSRs need to
intercept and see the EMS calls, and/or will make their own EMS calls by
cascading to the INT 67h handler in place before DV (thus making it so DV
cannot monitor the calls), and these behaviors would require this switch.
Note that high speed communications will stop working if this switch is
used because the bank-switching time to make EEMS calls through REMM is too
great.